package com.cyzy.controller;

import com.alibaba.fastjson2.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.cyzy.dto.R;
import com.cyzy.dto.UserPasswordDTO;
import com.cyzy.dto.UserPhoneDTO;
import com.cyzy.service.UserService;
import com.cyzy.utils.CodeUtils;
import com.cyzy.utils.TokenUtils;
import com.cyzy.vo.ExamAdmin;
import com.cyzy.vo.ExamUser;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.HttpSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private CodeUtils codeUtils;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private UserService userService;

    @RequestMapping("/test")
    public R test(){
        System.out.println("微服务上线了。。。。。");
        return R.ok().message("微服务上线了。。。。。");
    }

    @PostMapping("/login")
    public R login(@RequestBody ExamUser examUser, HttpServletRequest request){
//        if("admin".equals(examAdmin.getUsername()) && "123".equals(examAdmin.getPassword())){
//            //开启session，内部会生成唯一的ID，会自动写到cookie里；（key:jsessionid）
//            HttpSession session = request.getSession();
//            session.setAttribute("loginUser", examAdmin);
//            //存入到redis中
//            String token = TokenUtils.createToken(JSON.toJSONString(examAdmin));
//            redisTemplate.opsForValue().set(token, examAdmin,30, TimeUnit.MINUTES);
//            //响应token给前端
//
//            return R.ok().message("登录成功").data("token", token);
//        }else {
//            return R.ok().message("账号或密码错误");
//        }

        System.out.println(examUser+"--------------56");

        String key = examUser.getKey();
        String userCode = examUser.getCode();
        String code = (String) redisTemplate.opsForValue().get(key);
        System.out.println(userCode+"--------------61");
        System.out.println(code+"--------------62");

        if(userCode == null || "".equals(userCode)){
            return R.ok().code(500).message("验证码不能为空");
        }

        if(!userCode.equalsIgnoreCase(code)){
            return R.ok().code(500).message("验证码错误");
        }

        // 使用 MyBatis-Plus 查询用户
        LambdaQueryWrapper<ExamUser> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ExamUser::getWechat, examUser.getWechat()); // 查询用户名
        ExamUser userFromDb = userService.getOne(queryWrapper); // 获取单个用户

        if (userFromDb == null) {
            return R.ok().code(500).message("用户名或密码错误");
        }

        // 校验密码是否匹配
        if (!userFromDb.getPassword().equals(examUser.getPassword())) {
            return R.ok().code(500).message("用户名或密码错误");
        }

        // 校验账号状态是否正常
        if (userFromDb.getStatus() != 1) {
            return R.ok().code(500).message("黑名单用户，无法登录");
        }

        // 登录成功，存入Session并返回token
        HttpSession session = request.getSession();
        session.setAttribute("loginUser", userFromDb);

        // 生成token
        String token = TokenUtils.createToken(JSON.toJSONString(userFromDb));
        System.out.println("97------------token:"+token);
        redisTemplate.opsForValue().set(token, userFromDb, 30, TimeUnit.MINUTES);

        return R.ok().code(200).message("登录成功").data("token", token).data("userId", userFromDb.getId()).data("examLibraryId",userFromDb.getExamLibraryId());

    }

    @GetMapping("/getCode")
    public R getCode(HttpServletRequest request){
        String key = request.getSession().getId();
        String code = codeUtils.getRandomString();
        //存入redis中
        redisTemplate.opsForValue().set(key, code,30,TimeUnit.SECONDS);
        //返回给前端
        String Base64 = codeUtils.getImageOfBase64(code);
        Base64 = "data:image/jpeg;base64," + Base64;
        Map<String,String> map = new HashMap<>();
        map.put("key", key);
        map.put("base64", Base64);
        return R.ok().data("code", map);

    }

    @PostMapping("/register")
    public R register(@RequestBody ExamUser examUser) {
        // 使用 QueryWrapper 校验微信号是否已存在
        QueryWrapper<ExamUser> wechatQueryWrapper = new QueryWrapper<>();
        wechatQueryWrapper.eq("wechat", examUser.getWechat());
        ExamUser existingUserWechat = userService.getOne(wechatQueryWrapper);
        if (existingUserWechat != null) {
            return R.ok().code(500).message("微信号已存在");
        }

        // 使用 QueryWrapper 校验手机号是否已存在
        QueryWrapper<ExamUser> phoneQueryWrapper = new QueryWrapper<>();
        phoneQueryWrapper.eq("phone", examUser.getPhone());
        ExamUser existingUserPhone = userService.getOne(phoneQueryWrapper);
        if (existingUserPhone != null) {
            return R.ok().code(500).message("手机号已存在");
        }

        // 校验其他信息 (如密码长度、头像等)
        if (examUser.getPassword().length() < 6) {
            return R.ok().code(500).message("密码长度不能少于6个字符");
        }

        // 将 examLibraryId 设置为 null
        examUser.setExamLibraryId(0L);

        examUser.setStatus(1);

        // 保存用户数据
        boolean saved = userService.save(examUser);
        if (saved) {
            return R.ok().code(200).message("注册成功");
        } else {
            return R.ok().code(500).message("注册失败，请重试");
        }
    }

    @PostMapping("/updateUser")
    public R updateUser(@RequestBody ExamUser examUser) {
        try {
            // 根据传入的 examUser.id 查找对应的用户
            ExamUser existingUser = userService.getById(examUser.getId());

            if (existingUser == null) {
                return R.error().message("用户不存在");
            }

            // 如果用户存在，更新 examLibraryId
            existingUser.setExamLibraryId(examUser.getExamLibraryId());

            // 更新用户数据
            boolean result = userService.updateById(existingUser);

            if (result) {
                return R.ok().code(200).message("修改成功");
            } else {
                return R.error().message("修改失败");
            }

        } catch (Exception e) {
            e.printStackTrace();
            return R.error().message("系统异常");
        }
    }

    @GetMapping("/getUserById")
    public R getUserById(@RequestParam("userId")int userId){
        return R.ok().data("user",userService.getById(userId));
    }

    @PostMapping("/changePassword")
    public R changePassword(@RequestBody UserPasswordDTO userPasswordDTO){
        // 获取用户ID和密码信息
        int userId = userPasswordDTO.getUserId();
        String currentPassword = userPasswordDTO.getCurrentPassword();
        String newPassword = userPasswordDTO.getNewPassword();

        // 通过userId从数据库中查询当前用户的密码
        ExamUser examUser = userService.getById(userId);

        if (examUser == null) {
            return R.ok().code(500).message("用户不存在");
        }

        // 对比输入的当前密码和数据库中的密码
        if (!examUser.getPassword().equals(currentPassword)) {
            return R.ok().code(500).message("当前密码错误");
        }

        // 校验新密码是否合法，假设新密码需要至少6位
        if (newPassword.length() < 6) {
            return R.ok().code(500).message("新密码至少为6位");
        }

        // 修改用户密码
        examUser.setPassword(newPassword);
        boolean updateSuccess = userService.updateById(examUser);  // 使用 MyBatis-Plus 更新用户密码

        if (updateSuccess) {
            return R.ok().code(200).message("密码修改成功");
        } else {
            return R.ok().code(500).message("密码修改失败");
        }
    }

    @PostMapping("/changePhone")
    public R changePhone(@RequestBody UserPhoneDTO userPhoneDTO){
        // 获取用户ID和手机号信息
        int userId = userPhoneDTO.getUserId();
        String currentPhone = userPhoneDTO.getCurrentPhone();
        String newPhone = userPhoneDTO.getNewPhone();

        // 通过userId从数据库中查询当前用户的手机号
        ExamUser examUser = userService.getById(userId);

        if (examUser == null) {
            return R.ok().code(500).message("用户不存在");
        }

        // 对比输入的当前手机号和数据库中的手机号
        if (!examUser.getPhone().equals(currentPhone)) {
            return R.ok().code(500).message("当前手机号错误");
        }

        // 校验新手机号是否合法，假设使用简单的手机号正则校验
        String phoneRegex = "^1[3-9]\\d{9}$";
        if (!newPhone.matches(phoneRegex)) {
            return R.ok().code(500).message("请输入有效的手机号");
        }

        // 检查新手机号是否已被其他用户使用（直接在Controller层实现）
        QueryWrapper<ExamUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("phone", newPhone);
        ExamUser existingUser = userService.getOne(queryWrapper); // 使用 MyBatis-Plus 查询

        if (existingUser != null && existingUser.getId() != userId) {
            return R.ok().code(500).message("该手机号已被其他用户使用");
        }

        // 修改用户手机号
        examUser.setPhone(newPhone);
        boolean updateSuccess = userService.updateById(examUser);  // 使用 MyBatis-Plus 更新用户手机号

        if (updateSuccess) {
            return R.ok().code(200).message("手机号修改成功");
        } else {
            return R.ok().code(500).message("手机号修改失败");
        }
    }


}
